package com.gengzp.rpc.tools;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gengzp.rpc.exception.RpcException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Type;
import java.util.Map;

/**
 * @ClassName RpcJsonConvertor
 * @Description rpc框架json转换器
 * @Author gengzp
 * @Date 2025/8/20 20:59
 */
public class RpcJsonConvertor {

    private static final Logger logger = LoggerFactory.getLogger(RpcJsonConvertor.class);

    private static final ObjectMapper objectMapper;

    static {
        objectMapper = new ObjectMapper();
        // 忽略 JSON 中存在但目标类没有的字段（避免未知属性导致的转换失败）
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 允许空字符串转 null（如 JSON 中 "" 转 String 为 null，而非 ""）
        objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
    }

    private RpcJsonConvertor() {
    }

    /**
     * 将json字符串转换为指定泛型对象
     *
     * @param json  json字符串
     * @param clazz 指定泛型对象类型
     * @param <T>   泛型对象类型
     * @return 指定泛型对象
     */
    public static <T> T convertJsonToObject(String json, Class<T> clazz) throws RpcException {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (Exception e) {
            logger.error("json转换异常", e);
            throw RpcException.get(String.format("json转换异常:%s", e.getMessage()));
        }
    }

    /**
     * 将对象转换为指定类型
     *
     * @param obj        要转换的对象
     * @param targetType 指定类型
     * @param <T>        泛型对象类型
     * @return 指定泛型对象
     */
    public static <T> T convertObjToSpecificType(Object obj, Type targetType) throws RpcException {
        try {
            return objectMapper.readValue(convertObjectToJson(obj),
                    objectMapper.getTypeFactory().constructType(targetType));
        } catch (Exception e) {
            logger.error("json转换异常", e);
            throw RpcException.get(String.format("json转换异常:%s", e.getMessage()));
        }
    }

    /**
     * 将json字符串转换为带指定泛型对象
     *
     * @param json          json字符串
     * @param typeReference 指定泛型的集合对象类型的typeReference对象
     * @param <T>           泛型对象类型
     * @return 指定泛型的集合对象
     */
    public static <T> T convertJsonToGenericObject(String json, TypeReference<T> typeReference) throws RpcException {
        try {
            return objectMapper.readValue(json, typeReference);
        } catch (Exception e) {
            logger.error("json转换异常", e);
            throw RpcException.get(String.format("json转换异常:%s", e.getMessage()));
        }
    }

    /**
     * 将对象转为json字符串
     *
     * @param object 对象
     * @return json字符串
     */
    public static String convertObjectToJson(Object object) throws RpcException {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (Exception e) {
            logger.error("json转换异常", e);
            throw RpcException.get(String.format("json转换异常:%s", e.getMessage()));

        }
    }

    /**
     * 将对象转为Map<String, Object>
     *
     * @param obj 待转换的对象
     * @return 转换后的Map
     */
    public static Map<String, Object> convertObjectToMap(Object obj) throws RpcException {
        if (obj == null) {
            throw RpcException.get("待转换对象不能为空");
        }
        // 使用convertValue直接转换
        return objectMapper.convertValue(obj, new TypeReference<>() {
        });
    }

}
